home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gas_251.zip / bin_251 / bfd / nlmcode.h < prev    next >
C/C++ Source or Header  |  1994-06-21  |  66KB  |  2,084 lines
  1. /* NLM (NetWare Loadable Module) executable support for BFD.
  2.    Copyright (C) 1993 Free Software Foundation, Inc.
  3.  
  4.    Written by Fred Fish @ Cygnus Support, using ELF support as the
  5.    template.
  6.  
  7. This file is part of BFD, the Binary File Descriptor library.
  8.  
  9. This program is free software; you can redistribute it and/or modify
  10. it under the terms of the GNU General Public License as published by
  11. the Free Software Foundation; either version 2 of the License, or
  12. (at your option) any later version.
  13.  
  14. This program is distributed in the hope that it will be useful,
  15. but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17. GNU General Public License for more details.
  18.  
  19. You should have received a copy of the GNU General Public License
  20. along with this program; if not, write to the Free Software
  21. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22.  
  23. #include <string.h>        /* For strrchr and friends */
  24. #include "bfd.h"
  25. #include "sysdep.h"
  26. #include "libbfd.h"
  27. #include "libnlm.h"
  28.  
  29. /* The functions in this file do not use the names they appear to use.
  30.    This file is actually compiled multiple times, once for each size
  31.    of NLM target we are using.  At each size we use a different name,
  32.    constructed by the macro nlmNAME.  For example, the function which
  33.    is named nlm_symbol_type below is actually named nlm32_symbol_type
  34.    in the final executable.  */
  35.  
  36. #define Nlm_External_Fixed_Header    NlmNAME(External_Fixed_Header)
  37. #define Nlm_External_Version_Header    NlmNAME(External_Version_Header)
  38. #define Nlm_External_Copyright_Header    NlmNAME(External_Copyright_Header)
  39. #define Nlm_External_Extended_Header    NlmNAME(External_Extended_Header)
  40. #define Nlm_External_Custom_Header    NlmNAME(External_Custom_Header)
  41. #define Nlm_External_Cygnus_Ext_Header    NlmNAME(External_Cygnus_Ext_Header)
  42.  
  43. #define nlm_symbol_type            nlmNAME(symbol_type)
  44. #define nlm_get_symtab_upper_bound    nlmNAME(get_symtab_upper_bound)
  45. #define nlm_get_symtab            nlmNAME(get_symtab)
  46. #define nlm_make_empty_symbol        nlmNAME(make_empty_symbol)
  47. #define nlm_print_symbol        nlmNAME(print_symbol)
  48. #define nlm_get_symbol_info        nlmNAME(get_symbol_info)
  49. #define nlm_get_reloc_upper_bound    nlmNAME(get_reloc_upper_bound)
  50. #define nlm_canonicalize_reloc        nlmNAME(canonicalize_reloc)
  51. #define nlm_object_p            nlmNAME(object_p)
  52. #define nlm_set_section_contents    nlmNAME(set_section_contents)
  53. #define nlm_write_object_contents    nlmNAME(write_object_contents)
  54.  
  55. #define nlm_swap_fixed_header_in(abfd,src,dst) \
  56.   (nlm_swap_fixed_header_in_func(abfd))(abfd,src,dst)
  57. #define nlm_swap_fixed_header_out(abfd,src,dst) \
  58.   (nlm_swap_fixed_header_out_func(abfd))(abfd,src,dst)
  59.  
  60. /* Forward declarations of static functions */
  61.  
  62. static boolean add_bfd_section
  63.   PARAMS ((bfd *, char *, file_ptr, bfd_size_type, flagword));
  64. static boolean nlm_swap_variable_header_in
  65.   PARAMS ((bfd *));
  66. static boolean nlm_swap_variable_header_out
  67.   PARAMS ((bfd *));
  68. static boolean find_nonzero
  69.   PARAMS ((PTR, size_t));
  70. static boolean nlm_swap_auxiliary_headers_in
  71.   PARAMS ((bfd *));
  72. static boolean nlm_swap_auxiliary_headers_out
  73.   PARAMS ((bfd *));
  74. static boolean nlm_slurp_symbol_table
  75.   PARAMS ((bfd *));
  76. static boolean nlm_slurp_reloc_fixups
  77.   PARAMS ((bfd *));
  78. static boolean nlm_compute_section_file_positions
  79.   PARAMS ((bfd *));
  80. static int nlm_external_reloc_compare
  81.   PARAMS ((const void *, const void *));
  82.  
  83. /* Should perhaps use put_offset, put_word, etc.  For now, the two versions
  84.    can be handled by explicitly specifying 32 bits or "the long type".  */
  85. #if ARCH_SIZE == 64
  86. #define put_word    bfd_h_put_64
  87. #define get_word    bfd_h_get_64
  88. #endif
  89. #if ARCH_SIZE == 32
  90. #define put_word    bfd_h_put_32
  91. #define get_word    bfd_h_get_32
  92. #endif
  93.  
  94. const bfd_target *
  95. nlm_object_p (abfd)
  96.      bfd *abfd;
  97. {
  98.   struct nlm_obj_tdata *preserved_tdata = nlm_tdata (abfd);
  99.   boolean (*backend_object_p) PARAMS ((bfd *));
  100.   PTR x_fxdhdr = NULL;
  101.   Nlm_Internal_Fixed_Header *i_fxdhdrp;
  102.   struct nlm_obj_tdata *new_tdata = NULL;
  103.   const char *signature;
  104.   enum bfd_architecture arch;
  105.  
  106.   /* Some NLM formats have a prefix before the standard NLM fixed
  107.      header.  */
  108.   backend_object_p = nlm_backend_object_p_func (abfd);
  109.   if (backend_object_p)
  110.     {
  111.       if (!(*backend_object_p) (abfd))
  112.     goto got_wrong_format_error;
  113.     }
  114.  
  115.   /* Read in the fixed length portion of the NLM header in external format.  */
  116.  
  117.   x_fxdhdr = (PTR) malloc (nlm_fixed_header_size (abfd));
  118.   if (x_fxdhdr == NULL)
  119.     {
  120.       bfd_set_error (bfd_error_no_memory);
  121.       goto got_no_match;
  122.     }
  123.  
  124.   if (bfd_read ((PTR) x_fxdhdr, nlm_fixed_header_size (abfd), 1, abfd) !=
  125.       nlm_fixed_header_size (abfd))
  126.     {
  127.       if (bfd_get_error () != bfd_error_system_call)
  128.     goto got_wrong_format_error;
  129.       else
  130.     goto got_no_match;
  131.     }
  132.  
  133.   /* Allocate an instance of the nlm_obj_tdata structure and hook it up to
  134.      the tdata pointer in the bfd.  */
  135.  
  136.   new_tdata = ((struct nlm_obj_tdata *)
  137.            bfd_zalloc (abfd, sizeof (struct nlm_obj_tdata)));
  138.   if (new_tdata == NULL)
  139.     {
  140.       bfd_set_error (bfd_error_no_memory);
  141.       goto got_no_match;
  142.     }
  143.  
  144.   nlm_tdata (abfd) = new_tdata;
  145.  
  146.   i_fxdhdrp = nlm_fixed_header (abfd);
  147.   nlm_swap_fixed_header_in (abfd, x_fxdhdr, i_fxdhdrp);
  148.   free (x_fxdhdr);
  149.   x_fxdhdr = NULL;
  150.  
  151.   /* Check to see if we have an NLM file for this backend by matching
  152.      the NLM signature. */
  153.  
  154.   signature = nlm_signature (abfd);
  155.   if (signature != NULL
  156.       && *signature != '\0'
  157.       && strncmp ((char *) i_fxdhdrp->signature, signature,
  158.           NLM_SIGNATURE_SIZE) != 0)
  159.     goto got_wrong_format_error;
  160.  
  161.   /* There's no supported way to discover the endianess of an NLM, so test for
  162.      a sane version number after doing byte swapping appropriate for this
  163.      XVEC.  (Hack alert!) */
  164.  
  165.   if (i_fxdhdrp->version > 0xFFFF)
  166.     goto got_wrong_format_error;
  167.  
  168.   /* There's no supported way to check for 32 bit versus 64 bit addresses,
  169.      so ignore this distinction for now.  (FIXME) */
  170.  
  171.   /* Swap in the rest of the required header.  */
  172.   if (!nlm_swap_variable_header_in (abfd))
  173.     {
  174.       if (bfd_get_error () != bfd_error_system_call)
  175.     goto got_wrong_format_error;
  176.       else
  177.     goto got_no_match;
  178.     }
  179.  
  180.   /* Add the sections supplied by all NLM's, and then read in the
  181.      auxiliary headers.  Reading the auxiliary headers may create
  182.      additional sections described in the cygnus_ext header.
  183.      From this point on we assume that we have an NLM, and do not
  184.      treat errors as indicating the wrong format.  */
  185.  
  186.   if (!add_bfd_section (abfd, NLM_CODE_NAME,
  187.             i_fxdhdrp->codeImageOffset,
  188.             i_fxdhdrp->codeImageSize,
  189.             (SEC_CODE | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
  190.              | SEC_RELOC))
  191.       || !add_bfd_section (abfd, NLM_INITIALIZED_DATA_NAME,
  192.                i_fxdhdrp->dataImageOffset,
  193.                i_fxdhdrp->dataImageSize,
  194.                (SEC_DATA | SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
  195.                 | SEC_RELOC))
  196.       || !add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
  197.                (file_ptr) 0,
  198.                i_fxdhdrp->uninitializedDataSize,
  199.                SEC_ALLOC))
  200.     goto got_no_match;
  201.  
  202.   if (!nlm_swap_auxiliary_headers_in (abfd))
  203.     goto got_no_match;
  204.  
  205.   if (nlm_fixed_header (abfd)->numberOfRelocationFixups != 0
  206.       || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
  207.     abfd->flags |= HAS_RELOC;
  208.   if (nlm_fixed_header (abfd)->numberOfPublics != 0
  209.       || nlm_fixed_header (abfd)->numberOfDebugRecords != 0
  210.       || nlm_fixed_header (abfd)->numberOfExternalReferences != 0)
  211.     abfd->flags |= HAS_SYMS;
  212.  
  213.   arch = nlm_architecture (abfd);
  214.   if (arch != bfd_arch_unknown)
  215.     bfd_default_set_arch_mach (abfd, arch, (unsigned long) 0);
  216.  
  217.   abfd->flags |= EXEC_P;
  218.   bfd_get_start_address (abfd) = nlm_fixed_header (abfd)->codeStartOffset;
  219.  
  220.   return (abfd->xvec);
  221.  
  222. got_wrong_format_error:
  223.   bfd_set_error (bfd_error_wrong_format);
  224. got_no_match:
  225.   nlm_tdata (abfd) = preserved_tdata;
  226.   if (new_tdata != NULL)
  227.     bfd_release (abfd, new_tdata);
  228.   if (x_fxdhdr != NULL)
  229.     free (x_fxdhdr);
  230.   return (NULL);
  231. }
  232.  
  233. /* Add a section to the bfd. */
  234.  
  235. static boolean
  236. add_bfd_section (abfd, name, offset, size, flags)
  237.      bfd *abfd;
  238.      char *name;
  239.      file_ptr offset;
  240.      bfd_size_type size;
  241.      flagword flags;
  242. {
  243.   asection *newsect;
  244.  
  245.   newsect = bfd_make_section (abfd, name);
  246.   if (newsect == NULL)
  247.     {
  248.       return (false);
  249.     }
  250.   newsect->vma = 0;        /* NLM's are relocatable. */
  251.   newsect->_raw_size = size;
  252.   newsect->filepos = offset;
  253.   newsect->flags = flags;
  254.   newsect->alignment_power = bfd_log2 (0);    /* FIXME */
  255.   return (true);
  256. }
  257.  
  258. /* Read and swap in the variable length header.  All the fields must
  259.    exist in the NLM, and must exist in the order they are read here. */
  260.  
  261. static boolean
  262. nlm_swap_variable_header_in (abfd)
  263.      bfd *abfd;
  264. {
  265.   unsigned char temp[NLM_TARGET_LONG_SIZE];
  266.  
  267.   /* Read the description length and text members. */
  268.  
  269.   if (bfd_read ((PTR) & nlm_variable_header (abfd)->descriptionLength,
  270.         sizeof (nlm_variable_header (abfd)->descriptionLength),
  271.         1, abfd) !=
  272.       sizeof (nlm_variable_header (abfd)->descriptionLength))
  273.     return (false);
  274.   if (bfd_read ((PTR) nlm_variable_header (abfd)->descriptionText,
  275.         nlm_variable_header (abfd)->descriptionLength + 1,
  276.         1, abfd) !=
  277.       nlm_variable_header (abfd)->descriptionLength + 1)
  278.     return (false);
  279.  
  280.   /* Read and convert the stackSize field. */
  281.  
  282.   if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
  283.     return (false);
  284.   nlm_variable_header (abfd)->stackSize = get_word (abfd, (bfd_byte *) temp);
  285.  
  286.   /* Read and convert the reserved field. */
  287.  
  288.   if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
  289.     return (false);
  290.   nlm_variable_header (abfd)->reserved = get_word (abfd, (bfd_byte *) temp);
  291.  
  292.   /* Read the oldThreadName field.  This field is a fixed length string. */
  293.  
  294.   if (bfd_read ((PTR) nlm_variable_header (abfd)->oldThreadName,
  295.         sizeof (nlm_variable_header (abfd)->oldThreadName),
  296.         1, abfd) !=
  297.       sizeof (nlm_variable_header (abfd)->oldThreadName))
  298.     return (false);
  299.  
  300.   /* Read the screen name length and text members. */
  301.  
  302.   if (bfd_read ((PTR) & nlm_variable_header (abfd)->screenNameLength,
  303.         sizeof (nlm_variable_header (abfd)->screenNameLength),
  304.         1, abfd) !=
  305.       sizeof (nlm_variable_header (abfd)->screenNameLength))
  306.     return (false);
  307.   if (bfd_read ((PTR) nlm_variable_header (abfd)->screenName,
  308.         nlm_variable_header (abfd)->screenNameLength + 1,
  309.         1, abfd) !=
  310.       nlm_variable_header (abfd)->screenNameLength + 1)
  311.     return (false);
  312.  
  313.   /* Read the thread name length and text members. */
  314.  
  315.   if (bfd_read ((PTR) & nlm_variable_header (abfd)->threadNameLength,
  316.         sizeof (nlm_variable_header (abfd)->threadNameLength),
  317.         1, abfd) !=
  318.       sizeof (nlm_variable_header (abfd)->threadNameLength))
  319.     return (false);
  320.   if (bfd_read ((PTR) nlm_variable_header (abfd)->threadName,
  321.         nlm_variable_header (abfd)->threadNameLength + 1,
  322.         1, abfd) !=
  323.       nlm_variable_header (abfd)->threadNameLength + 1)
  324.     return (false);
  325.   return (true);
  326. }
  327.  
  328. /* Swap and write out the variable length header.  All the fields must
  329.    exist in the NLM, and must exist in this order.  */
  330.  
  331. static boolean
  332. nlm_swap_variable_header_out (abfd)
  333.      bfd *abfd;
  334. {
  335.   unsigned char temp[NLM_TARGET_LONG_SIZE];
  336.  
  337.   /* Write the description length and text members. */
  338.  
  339.   if (bfd_write ((PTR) & nlm_variable_header (abfd)->descriptionLength,
  340.          sizeof (nlm_variable_header (abfd)->descriptionLength),
  341.          1, abfd) !=
  342.       sizeof (nlm_variable_header (abfd)->descriptionLength))
  343.     return (false);
  344.   if (bfd_write ((PTR) nlm_variable_header (abfd)->descriptionText,
  345.          nlm_variable_header (abfd)->descriptionLength + 1,
  346.          1, abfd) !=
  347.       nlm_variable_header (abfd)->descriptionLength + 1)
  348.     return (false);
  349.  
  350.   /* Convert and write the stackSize field. */
  351.  
  352.   put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->stackSize,
  353.         (bfd_byte *) temp);
  354.   if (bfd_write ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
  355.     return (false);
  356.  
  357.   /* Convert and write the reserved field. */
  358.  
  359.   put_word (abfd, (bfd_vma) nlm_variable_header (abfd)->reserved,
  360.         (bfd_byte *) temp);
  361.   if (bfd_write ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
  362.     return (false);
  363.  
  364.   /* Write the oldThreadName field.  This field is a fixed length string. */
  365.  
  366.   if (bfd_write ((PTR) nlm_variable_header (abfd)->oldThreadName,
  367.          sizeof (nlm_variable_header (abfd)->oldThreadName),
  368.          1, abfd) !=
  369.       sizeof (nlm_variable_header (abfd)->oldThreadName))
  370.     return (false);
  371.  
  372.   /* Write the screen name length and text members. */
  373.  
  374.   if (bfd_write ((PTR) & nlm_variable_header (abfd)->screenNameLength,
  375.          sizeof (nlm_variable_header (abfd)->screenNameLength),
  376.          1, abfd) !=
  377.       sizeof (nlm_variable_header (abfd)->screenNameLength))
  378.     return (false);
  379.   if (bfd_write ((PTR) nlm_variable_header (abfd)->screenName,
  380.          nlm_variable_header (abfd)->screenNameLength + 1,
  381.          1, abfd) !=
  382.       nlm_variable_header (abfd)->screenNameLength + 1)
  383.     return (false);
  384.  
  385.   /* Write the thread name length and text members. */
  386.  
  387.   if (bfd_write ((PTR) & nlm_variable_header (abfd)->threadNameLength,
  388.          sizeof (nlm_variable_header (abfd)->threadNameLength),
  389.          1, abfd) !=
  390.       sizeof (nlm_variable_header (abfd)->threadNameLength))
  391.     return (false);
  392.   if (bfd_write ((PTR) nlm_variable_header (abfd)->threadName,
  393.          nlm_variable_header (abfd)->threadNameLength + 1,
  394.          1, abfd) !=
  395.       nlm_variable_header (abfd)->threadNameLength + 1)
  396.     return (false);
  397.   return (true);
  398. }
  399.  
  400. /* Read and swap in the contents of all the auxiliary headers.  Because of
  401.    the braindead design, we have to do strcmps on strings of indeterminate
  402.    length to figure out what each auxiliary header is.  Even worse, we have
  403.    no way of knowing how many auxiliary headers there are or where the end
  404.    of the auxiliary headers are, except by finding something that doesn't
  405.    look like a known auxiliary header.  This means that the first new type
  406.    of auxiliary header added will break all existing tools that don't
  407.    recognize it. */
  408.  
  409. static boolean
  410. nlm_swap_auxiliary_headers_in (abfd)
  411.      bfd *abfd;
  412. {
  413.   char tempstr[16];
  414.   long position;
  415.  
  416.   for (;;)
  417.     {
  418.       position = bfd_tell (abfd);
  419.       if (bfd_read ((PTR) tempstr, sizeof (tempstr), 1, abfd) !=
  420.       sizeof (tempstr))
  421.     return (false);
  422.       if (bfd_seek (abfd, position, SEEK_SET) == -1)
  423.     return (false);
  424.       if (strncmp (tempstr, "VeRsIoN#", 8) == 0)
  425.     {
  426.       Nlm_External_Version_Header thdr;
  427.       if (bfd_read ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
  428.         return (false);
  429.       memcpy (nlm_version_header (abfd)->stamp, thdr.stamp,
  430.           sizeof (thdr.stamp));
  431.       nlm_version_header (abfd)->majorVersion =
  432.         get_word (abfd, (bfd_byte *) thdr.majorVersion);
  433.       nlm_version_header (abfd)->minorVersion =
  434.         get_word (abfd, (bfd_byte *) thdr.minorVersion);
  435.       nlm_version_header (abfd)->revision =
  436.         get_word (abfd, (bfd_byte *) thdr.revision);
  437.       nlm_version_header (abfd)->year =
  438.         get_word (abfd, (bfd_byte *) thdr.year);
  439.       nlm_version_header (abfd)->month =
  440.         get_word (abfd, (bfd_byte *) thdr.month);
  441.       nlm_version_header (abfd)->day =
  442.         get_word (abfd, (bfd_byte *) thdr.day);
  443.     }
  444.       else if (strncmp (tempstr, "MeSsAgEs", 8) == 0)
  445.     {
  446.       Nlm_External_Extended_Header thdr;
  447.       if (bfd_read ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
  448.         return (false);
  449.       memcpy (nlm_extended_header (abfd)->stamp, thdr.stamp,
  450.           sizeof (thdr.stamp));
  451.       nlm_extended_header (abfd)->languageID =
  452.         get_word (abfd, (bfd_byte *) thdr.languageID);
  453.       nlm_extended_header (abfd)->messageFileOffset =
  454.         get_word (abfd, (bfd_byte *) thdr.messageFileOffset);
  455.       nlm_extended_header (abfd)->messageFileLength =
  456.         get_word (abfd, (bfd_byte *) thdr.messageFileLength);
  457.       nlm_extended_header (abfd)->messageCount =
  458.         get_word (abfd, (bfd_byte *) thdr.messageCount);
  459.       nlm_extended_header (abfd)->helpFileOffset =
  460.         get_word (abfd, (bfd_byte *) thdr.helpFileOffset);
  461.       nlm_extended_header (abfd)->helpFileLength =
  462.         get_word (abfd, (bfd_byte *) thdr.helpFileLength);
  463.       nlm_extended_header (abfd)->RPCDataOffset =
  464.         get_word (abfd, (bfd_byte *) thdr.RPCDataOffset);
  465.       nlm_extended_header (abfd)->RPCDataLength =
  466.         get_word (abfd, (bfd_byte *) thdr.RPCDataLength);
  467.       nlm_extended_header (abfd)->sharedCodeOffset =
  468.         get_word (abfd, (bfd_byte *) thdr.sharedCodeOffset);
  469.       nlm_extended_header (abfd)->sharedCodeLength =
  470.         get_word (abfd, (bfd_byte *) thdr.sharedCodeLength);
  471.       nlm_extended_header (abfd)->sharedDataOffset =
  472.         get_word (abfd, (bfd_byte *) thdr.sharedDataOffset);
  473.       nlm_extended_header (abfd)->sharedDataLength =
  474.         get_word (abfd, (bfd_byte *) thdr.sharedDataLength);
  475.       nlm_extended_header (abfd)->sharedRelocationFixupOffset =
  476.         get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupOffset);
  477.       nlm_extended_header (abfd)->sharedRelocationFixupCount =
  478.         get_word (abfd, (bfd_byte *) thdr.sharedRelocationFixupCount);
  479.       nlm_extended_header (abfd)->sharedExternalReferenceOffset =
  480.         get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceOffset);
  481.       nlm_extended_header (abfd)->sharedExternalReferenceCount =
  482.         get_word (abfd, (bfd_byte *) thdr.sharedExternalReferenceCount);
  483.       nlm_extended_header (abfd)->sharedPublicsOffset =
  484.         get_word (abfd, (bfd_byte *) thdr.sharedPublicsOffset);
  485.       nlm_extended_header (abfd)->sharedPublicsCount =
  486.         get_word (abfd, (bfd_byte *) thdr.sharedPublicsCount);
  487.       nlm_extended_header (abfd)->sharedDebugRecordOffset =
  488.         get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordOffset);
  489.       nlm_extended_header (abfd)->sharedDebugRecordCount =
  490.         get_word (abfd, (bfd_byte *) thdr.sharedDebugRecordCount);
  491.       nlm_extended_header (abfd)->SharedInitializationOffset =
  492.         get_word (abfd, (bfd_byte *) thdr.sharedInitializationOffset);
  493.       nlm_extended_header (abfd)->SharedExitProcedureOffset =
  494.         get_word (abfd, (bfd_byte *) thdr.SharedExitProcedureOffset);
  495.       nlm_extended_header (abfd)->productID =
  496.         get_word (abfd, (bfd_byte *) thdr.productID);
  497.       nlm_extended_header (abfd)->reserved0 =
  498.         get_word (abfd, (bfd_byte *) thdr.reserved0);
  499.       nlm_extended_header (abfd)->reserved1 =
  500.         get_word (abfd, (bfd_byte *) thdr.reserved1);
  501.       nlm_extended_header (abfd)->reserved2 =
  502.         get_word (abfd, (bfd_byte *) thdr.reserved2);
  503.       nlm_extended_header (abfd)->reserved3 =
  504.         get_word (abfd, (bfd_byte *) thdr.reserved3);
  505.       nlm_extended_header (abfd)->reserved4 =
  506.         get_word (abfd, (bfd_byte *) thdr.reserved4);
  507.       nlm_extended_header (abfd)->reserved5 =
  508.         get_word (abfd, (bfd_byte *) thdr.reserved5);
  509.     }
  510.       else if (strncmp (tempstr, "CoPyRiGhT=", 10) == 0)
  511.     {
  512.       if (bfd_read ((PTR) nlm_copyright_header (abfd)->stamp,
  513.             sizeof (nlm_copyright_header (abfd)->stamp),
  514.             1, abfd)
  515.           != sizeof (nlm_copyright_header (abfd)->stamp))
  516.         return (false);
  517.       if (bfd_read ((PTR) & (nlm_copyright_header (abfd)
  518.                  ->copyrightMessageLength),
  519.             1, 1, abfd) != 1)
  520.         return (false);
  521.       /* The copyright message is a variable length string. */
  522.       if (bfd_read ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
  523.             nlm_copyright_header (abfd)->copyrightMessageLength + 1,
  524.             1, abfd) !=
  525.           nlm_copyright_header (abfd)->copyrightMessageLength + 1)
  526.         return (false);
  527.     }
  528.       else if (strncmp (tempstr, "CuStHeAd", 8) == 0)
  529.     {
  530.       Nlm_External_Custom_Header thdr;
  531.       bfd_size_type hdrLength;
  532.       file_ptr dataOffset;
  533.       bfd_size_type dataLength;
  534.       char dataStamp[8];
  535.       PTR hdr;
  536.  
  537.       /* Read the stamp ("CuStHeAd").  */
  538.       if (bfd_read ((PTR) thdr.stamp, 1, sizeof (thdr.stamp), abfd)
  539.           != sizeof (thdr.stamp))
  540.         return false;
  541.       /* Read the length of this custom header.  */
  542.       if (bfd_read ((PTR) thdr.length, 1, sizeof (thdr.length), abfd)
  543.           != sizeof (thdr.length))
  544.         return false;
  545.       hdrLength = get_word (abfd, (bfd_byte *) thdr.length);
  546.       /* Read further fields if we have them.  */
  547.       if (hdrLength < NLM_TARGET_LONG_SIZE)
  548.         dataOffset = 0;
  549.       else
  550.         {
  551.           if (bfd_read ((PTR) thdr.dataOffset, 1,
  552.                 sizeof (thdr.dataOffset), abfd)
  553.           != sizeof (thdr.dataOffset))
  554.         return false;
  555.           dataOffset = get_word (abfd, (bfd_byte *) thdr.dataOffset);
  556.         }
  557.       if (hdrLength < 2 * NLM_TARGET_LONG_SIZE)
  558.         dataLength = 0;
  559.       else
  560.         {
  561.           if (bfd_read ((PTR) thdr.dataLength, 1,
  562.                 sizeof (thdr.dataLength), abfd)
  563.           != sizeof (thdr.dataLength))
  564.         return false;
  565.           dataLength = get_word (abfd, (bfd_byte *) thdr.dataLength);
  566.         }
  567.       if (hdrLength < 2 * NLM_TARGET_LONG_SIZE + 8)
  568.         memset (dataStamp, 0, sizeof (dataStamp));
  569.       else
  570.         {
  571.           if (bfd_read ((PTR) dataStamp, 1, sizeof (dataStamp), abfd)
  572.           != sizeof (dataStamp))
  573.         return false;
  574.         }
  575.  
  576.       /* Read the rest of the header, if any.  */
  577.       if (hdrLength <= 2 * NLM_TARGET_LONG_SIZE + 8)
  578.         {
  579.           hdr = NULL;
  580.           hdrLength = 0;
  581.         }
  582.       else
  583.         {
  584.           hdrLength -= 2 * NLM_TARGET_LONG_SIZE + 8;
  585.           hdr = bfd_alloc (abfd, hdrLength);
  586.           if (hdr == NULL)
  587.         {
  588.           bfd_set_error (bfd_error_no_memory);
  589.           return false;
  590.         }
  591.           if (bfd_read (hdr, 1, hdrLength, abfd) != hdrLength)
  592.         return false;
  593.         }
  594.  
  595.       /* If we have found a Cygnus header, process it.  Otherwise,
  596.          just save the associated data without trying to interpret
  597.          it.  */
  598.       if (strncmp (dataStamp, "CyGnUsEx", 8) == 0)
  599.         {
  600.           file_ptr pos;
  601.           bfd_byte *contents;
  602.           bfd_byte *p, *pend;
  603.  
  604.           BFD_ASSERT (hdrLength == 0 && hdr == NULL);
  605.  
  606.           pos = bfd_tell (abfd);
  607.           if (bfd_seek (abfd, dataOffset, SEEK_SET) != 0)
  608.         return false;
  609.           contents = (bfd_byte *) bfd_alloc (abfd, dataLength);
  610.           if (contents == NULL)
  611.         {
  612.           bfd_set_error (bfd_error_no_memory);
  613.           return false;
  614.         }
  615.           if (bfd_read (contents, 1, dataLength, abfd) != dataLength)
  616.         return false;
  617.           if (bfd_seek (abfd, pos, SEEK_SET) != 0)
  618.         return false;
  619.  
  620.           memcpy (nlm_cygnus_ext_header (abfd), "CyGnUsEx", 8);
  621.           nlm_cygnus_ext_header (abfd)->offset = dataOffset;
  622.           nlm_cygnus_ext_header (abfd)->length = dataLength;
  623.  
  624.           /* This data this header points to provides a list of
  625.          the sections which were in the original object file
  626.          which was converted to become an NLM.  We locate
  627.          those sections and add them to the BFD.  Note that
  628.          this is likely to create a second .text, .data and
  629.          .bss section; retrieving the sections by name will
  630.          get the actual NLM sections, which is what we want to
  631.          happen.  The sections from the original file, which
  632.          may be subsets of the NLM section, can only be found
  633.          using bfd_map_over_sections.  */
  634.           p = contents;
  635.           pend = p + dataLength;
  636.           while (p < pend)
  637.         {
  638.           char *name;
  639.           size_t l;
  640.           file_ptr filepos;
  641.           bfd_size_type size;
  642.           asection *newsec;
  643.  
  644.           /* The format of this information is
  645.              null terminated section name
  646.              zeroes to adjust to 4 byte boundary
  647.              4 byte section data file pointer
  648.              4 byte section size
  649.              */
  650.  
  651.           name = (char *) p;
  652.           l = strlen (name) + 1;
  653.           l = (l + 3) &~ 3;
  654.           p += l;
  655.           filepos = bfd_h_get_32 (abfd, p);
  656.           p += 4;
  657.           size = bfd_h_get_32 (abfd, p);
  658.           p += 4;
  659.  
  660.           newsec = bfd_make_section_anyway (abfd, name);
  661.           if (newsec == (asection *) NULL)
  662.             return false;
  663.           newsec->_raw_size = size;
  664.           if (filepos != 0)
  665.             {
  666.               newsec->filepos = filepos;
  667.               newsec->flags |= SEC_HAS_CONTENTS;
  668.             }
  669.         }
  670.         }
  671.       else
  672.         {
  673.           memcpy (nlm_custom_header (abfd)->stamp, thdr.stamp,
  674.               sizeof (thdr.stamp));
  675.           nlm_custom_header (abfd)->hdrLength = hdrLength;
  676.           nlm_custom_header (abfd)->dataOffset = dataOffset;
  677.           nlm_custom_header (abfd)->dataLength = dataLength;
  678.           memcpy (nlm_custom_header (abfd)->dataStamp, dataStamp,
  679.               sizeof (dataStamp));
  680.           nlm_custom_header (abfd)->hdr = hdr;
  681.         }
  682.     }
  683.       else
  684.     {
  685.       break;
  686.     }
  687.     }
  688.   return (true);
  689. }
  690.  
  691. /* Return whether there is a non-zero byte in a memory block.  */
  692.  
  693. static boolean
  694. find_nonzero (buf, size)
  695.      PTR buf;
  696.      size_t size;
  697. {
  698.   char *p = (char *) buf;
  699.  
  700.   while (size-- != 0)
  701.     if (*p++ != 0)
  702.       return true;
  703.   return false;
  704. }
  705.  
  706. /* Swap out the contents of the auxiliary headers.  We create those
  707.    auxiliary headers which have been set non-zero.  We do not require
  708.    the caller to set up the stamp fields.  */
  709.  
  710. static boolean
  711. nlm_swap_auxiliary_headers_out (abfd)
  712.      bfd *abfd;
  713. {
  714.   /* Write out the version header if there is one.  */
  715.   if (find_nonzero ((PTR) nlm_version_header (abfd),
  716.             sizeof (Nlm_Internal_Version_Header)))
  717.     {
  718.       Nlm_External_Version_Header thdr;
  719.  
  720.       memcpy (thdr.stamp, "VeRsIoN#", 8);
  721.       put_word (abfd, (bfd_vma) nlm_version_header (abfd)->majorVersion,
  722.         (bfd_byte *) thdr.majorVersion);
  723.       put_word (abfd, (bfd_vma) nlm_version_header (abfd)->minorVersion,
  724.         (bfd_byte *) thdr.minorVersion);
  725.       put_word (abfd, (bfd_vma) nlm_version_header (abfd)->revision,
  726.         (bfd_byte *) thdr.revision);
  727.       put_word (abfd, (bfd_vma) nlm_version_header (abfd)->year,
  728.         (bfd_byte *) thdr.year);
  729.       put_word (abfd, (bfd_vma) nlm_version_header (abfd)->month,
  730.         (bfd_byte *) thdr.month);
  731.       put_word (abfd, (bfd_vma) nlm_version_header (abfd)->day,
  732.         (bfd_byte *) thdr.day);
  733.       if (bfd_write ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
  734.     return false;
  735.     }
  736.  
  737.   /* Write out the extended header if there is one.  */
  738.   if (find_nonzero ((PTR) nlm_extended_header (abfd),
  739.             sizeof (Nlm_Internal_Extended_Header)))
  740.     {
  741.       Nlm_External_Extended_Header thdr;
  742.  
  743.       memcpy (thdr.stamp, "MeSsAgEs", 8);
  744.       put_word (abfd,
  745.         (bfd_vma) nlm_extended_header (abfd)->languageID,
  746.         (bfd_byte *) thdr.languageID);
  747.       put_word (abfd,
  748.         (bfd_vma) nlm_extended_header (abfd)->messageFileOffset,
  749.         (bfd_byte *) thdr.messageFileOffset);
  750.       put_word (abfd,
  751.         (bfd_vma) nlm_extended_header (abfd)->messageFileLength,
  752.         (bfd_byte *) thdr.messageFileLength);
  753.       put_word (abfd,
  754.         (bfd_vma) nlm_extended_header (abfd)->messageCount,
  755.         (bfd_byte *) thdr.messageCount);
  756.       put_word (abfd,
  757.         (bfd_vma) nlm_extended_header (abfd)->helpFileOffset,
  758.         (bfd_byte *) thdr.helpFileOffset);
  759.       put_word (abfd,
  760.         (bfd_vma) nlm_extended_header (abfd)->helpFileLength,
  761.         (bfd_byte *) thdr.helpFileLength);
  762.       put_word (abfd,
  763.         (bfd_vma) nlm_extended_header (abfd)->RPCDataOffset,
  764.         (bfd_byte *) thdr.RPCDataOffset);
  765.       put_word (abfd,
  766.         (bfd_vma) nlm_extended_header (abfd)->RPCDataLength,
  767.         (bfd_byte *) thdr.RPCDataLength);
  768.       put_word (abfd,
  769.         (bfd_vma) nlm_extended_header (abfd)->sharedCodeOffset,
  770.         (bfd_byte *) thdr.sharedCodeOffset);
  771.       put_word (abfd,
  772.         (bfd_vma) nlm_extended_header (abfd)->sharedCodeLength,
  773.         (bfd_byte *) thdr.sharedCodeLength);
  774.       put_word (abfd,
  775.         (bfd_vma) nlm_extended_header (abfd)->sharedDataOffset,
  776.         (bfd_byte *) thdr.sharedDataOffset);
  777.       put_word (abfd,
  778.         (bfd_vma) nlm_extended_header (abfd)->sharedDataLength,
  779.         (bfd_byte *) thdr.sharedDataLength);
  780.       put_word (abfd,
  781.       (bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupOffset,
  782.         (bfd_byte *) thdr.sharedRelocationFixupOffset);
  783.       put_word (abfd,
  784.        (bfd_vma) nlm_extended_header (abfd)->sharedRelocationFixupCount,
  785.         (bfd_byte *) thdr.sharedRelocationFixupCount);
  786.       put_word (abfd,
  787.     (bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceOffset,
  788.         (bfd_byte *) thdr.sharedExternalReferenceOffset);
  789.       put_word (abfd,
  790.      (bfd_vma) nlm_extended_header (abfd)->sharedExternalReferenceCount,
  791.         (bfd_byte *) thdr.sharedExternalReferenceCount);
  792.       put_word (abfd,
  793.         (bfd_vma) nlm_extended_header (abfd)->sharedPublicsOffset,
  794.         (bfd_byte *) thdr.sharedPublicsOffset);
  795.       put_word (abfd,
  796.         (bfd_vma) nlm_extended_header (abfd)->sharedPublicsCount,
  797.         (bfd_byte *) thdr.sharedPublicsCount);
  798.       put_word (abfd,
  799.           (bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordOffset,
  800.         (bfd_byte *) thdr.sharedDebugRecordOffset);
  801.       put_word (abfd,
  802.         (bfd_vma) nlm_extended_header (abfd)->sharedDebugRecordCount,
  803.         (bfd_byte *) thdr.sharedDebugRecordCount);
  804.       put_word (abfd,
  805.        (bfd_vma) nlm_extended_header (abfd)->SharedInitializationOffset,
  806.         (bfd_byte *) thdr.sharedInitializationOffset);
  807.       put_word (abfd,
  808.         (bfd_vma) nlm_extended_header (abfd)->SharedExitProcedureOffset,
  809.         (bfd_byte *) thdr.SharedExitProcedureOffset);
  810.       put_word (abfd,
  811.         (bfd_vma) nlm_extended_header (abfd)->productID,
  812.         (bfd_byte *) thdr.productID);
  813.       put_word (abfd,
  814.         (bfd_vma) nlm_extended_header (abfd)->reserved0,
  815.         (bfd_byte *) thdr.reserved0);
  816.       put_word (abfd,
  817.         (bfd_vma) nlm_extended_header (abfd)->reserved1,
  818.         (bfd_byte *) thdr.reserved1);
  819.       put_word (abfd,
  820.         (bfd_vma) nlm_extended_header (abfd)->reserved2,
  821.         (bfd_byte *) thdr.reserved2);
  822.       put_word (abfd,
  823.         (bfd_vma) nlm_extended_header (abfd)->reserved3,
  824.         (bfd_byte *) thdr.reserved3);
  825.       put_word (abfd,
  826.         (bfd_vma) nlm_extended_header (abfd)->reserved4,
  827.         (bfd_byte *) thdr.reserved4);
  828.       put_word (abfd,
  829.         (bfd_vma) nlm_extended_header (abfd)->reserved5,
  830.         (bfd_byte *) thdr.reserved5);
  831.       if (bfd_write ((PTR) & thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
  832.     return false;
  833.     }
  834.  
  835.  
  836.   /* Write out the copyright header if there is one.  */
  837.   if (find_nonzero ((PTR) nlm_copyright_header (abfd),
  838.             sizeof (Nlm_Internal_Copyright_Header)))
  839.     {
  840.       Nlm_External_Copyright_Header thdr;
  841.  
  842.       memcpy (thdr.stamp, "CoPyRiGhT=", 10);
  843.       if (bfd_write ((PTR) thdr.stamp, sizeof (thdr.stamp), 1, abfd)
  844.       != sizeof (thdr.stamp))
  845.     return false;
  846.       thdr.copyrightMessageLength[0] =
  847.     nlm_copyright_header (abfd)->copyrightMessageLength;
  848.       if (bfd_write ((PTR) thdr.copyrightMessageLength, 1, 1, abfd) != 1)
  849.     return false;
  850.       /* The copyright message is a variable length string. */
  851.       if (bfd_write ((PTR) nlm_copyright_header (abfd)->copyrightMessage,
  852.              nlm_copyright_header (abfd)->copyrightMessageLength + 1,
  853.              1, abfd) !=
  854.       nlm_copyright_header (abfd)->copyrightMessageLength + 1)
  855.     return false;
  856.     }
  857.  
  858.   /* Write out the custom header if there is one.   */
  859.   if (find_nonzero ((PTR) nlm_custom_header (abfd),
  860.             sizeof (Nlm_Internal_Custom_Header)))
  861.     {
  862.       Nlm_External_Custom_Header thdr;
  863.       boolean ds;
  864.       bfd_size_type hdrLength;
  865.  
  866.       ds = find_nonzero ((PTR) nlm_custom_header (abfd)->dataStamp,
  867.              sizeof (nlm_custom_header (abfd)->dataStamp));
  868.       memcpy (thdr.stamp, "CuStHeAd", 8);
  869.       hdrLength = (2 * NLM_TARGET_LONG_SIZE + (ds ? 8 : 0)
  870.            + nlm_custom_header (abfd)->hdrLength);
  871.       put_word (abfd, hdrLength, thdr.length);
  872.       put_word (abfd, (bfd_vma) nlm_custom_header (abfd)->dataOffset,
  873.         thdr.dataOffset);
  874.       put_word (abfd, (bfd_vma) nlm_custom_header (abfd)->dataLength,
  875.         thdr.dataLength);
  876.       if (! ds)
  877.     {
  878.       BFD_ASSERT (nlm_custom_header (abfd)->hdrLength == 0);
  879.       if (bfd_write ((PTR) &thdr, 1,
  880.              sizeof (thdr) - sizeof (thdr.dataStamp), abfd)
  881.           != sizeof (thdr) - sizeof (thdr.dataStamp))
  882.         return false;
  883.     }
  884.       else
  885.     {
  886.       memcpy (thdr.dataStamp, nlm_custom_header (abfd)->dataStamp,
  887.           sizeof (thdr.dataStamp));
  888.       if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
  889.         return false;
  890.       if (bfd_write (nlm_custom_header (abfd)->hdr, 1,
  891.              nlm_custom_header (abfd)->hdrLength, abfd)
  892.           != nlm_custom_header (abfd)->hdrLength)
  893.         return false;
  894.     }
  895.     }
  896.  
  897.   /* Write out the Cygnus debugging header if there is one.  */
  898.   if (find_nonzero ((PTR) nlm_cygnus_ext_header (abfd),
  899.             sizeof (Nlm_Internal_Cygnus_Ext_Header)))
  900.     {
  901.       Nlm_External_Custom_Header thdr;
  902.  
  903.       memcpy (thdr.stamp, "CuStHeAd", 8);
  904.       put_word (abfd, (bfd_vma) 2 * NLM_TARGET_LONG_SIZE + 8,
  905.         (bfd_byte *) thdr.length);
  906.       put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->offset,
  907.         (bfd_byte *) thdr.dataOffset);
  908.       put_word (abfd, (bfd_vma) nlm_cygnus_ext_header (abfd)->length,
  909.         (bfd_byte *) thdr.dataLength);
  910.       memcpy (thdr.dataStamp, "CyGnUsEx", 8);
  911.       if (bfd_write ((PTR) &thdr, sizeof (thdr), 1, abfd) != sizeof (thdr))
  912.     return false;
  913.     }
  914.  
  915.   return true;
  916. }
  917.  
  918. /* We read the NLM's public symbols and use it to generate a bfd symbol
  919.    table (hey, it's better than nothing) on a one-for-one basis.  Thus
  920.    use the number of public symbols as the number of bfd symbols we will
  921.    have once we actually get around to reading them in.
  922.  
  923.    Return the number of bytes required to hold the symtab vector, based on
  924.    the count plus 1, since we will NULL terminate the vector allocated based
  925.    on this size. */
  926.  
  927. long
  928. nlm_get_symtab_upper_bound (abfd)
  929.      bfd *abfd;
  930. {
  931.   Nlm_Internal_Fixed_Header *i_fxdhdrp;    /* Nlm file header, internal form */
  932.   long symcount;
  933.   long symtab_size = 0;
  934.  
  935.   i_fxdhdrp = nlm_fixed_header (abfd);
  936.   symcount = (i_fxdhdrp->numberOfPublics
  937.           + i_fxdhdrp->numberOfDebugRecords
  938.           + i_fxdhdrp->numberOfExternalReferences);
  939.   symtab_size = (symcount + 1) * (sizeof (asymbol));
  940.   return (symtab_size);
  941. }
  942.  
  943. /* Note that bfd_get_symcount is guaranteed to be zero if slurping the
  944.    symbol table fails. */
  945.  
  946. long
  947. nlm_get_symtab (abfd, alocation)
  948.      bfd *abfd;
  949.      asymbol **alocation;
  950. {
  951.   nlm_symbol_type *symbase;
  952.   bfd_size_type counter = 0;
  953.  
  954.   if (nlm_slurp_symbol_table (abfd) == false)
  955.     return -1;
  956.   symbase = nlm_get_symbols (abfd);
  957.   while (counter < bfd_get_symcount (abfd))
  958.     {
  959.       *alocation++ = &symbase->symbol;
  960.       symbase++;
  961.       counter++;
  962.     }
  963.   *alocation = (asymbol *) NULL;
  964.   return bfd_get_symcount (abfd);
  965. }
  966.  
  967. /* Make an NLM symbol.  There is nothing special to do here.  */
  968.  
  969. asymbol *
  970. nlm_make_empty_symbol (abfd)
  971.      bfd *abfd;
  972. {
  973.   nlm_symbol_type *new;
  974.  
  975.   new = (nlm_symbol_type *) bfd_zalloc (abfd, sizeof (nlm_symbol_type));
  976.   if (new)
  977.     new->symbol.the_bfd = abfd;
  978.   return &new->symbol;
  979. }
  980.  
  981. /* Get symbol information.  */
  982.  
  983. void
  984. nlm_get_symbol_info (ignore_abfd, symbol, ret)
  985.      bfd *ignore_abfd;
  986.      asymbol *symbol;
  987.      symbol_info *ret;
  988. {
  989.   bfd_symbol_info (symbol, ret);
  990. }
  991.  
  992. /* Print symbol information.  */
  993.  
  994. void
  995. nlm_print_symbol (abfd, afile, symbol, how)
  996.      bfd *abfd;
  997.      PTR afile;
  998.      asymbol *symbol;
  999.      bfd_print_symbol_type how;
  1000. {
  1001.   FILE *file = (FILE *) afile;
  1002.  
  1003.   switch (how)
  1004.     {
  1005.     case bfd_print_symbol_name:
  1006.     case bfd_print_symbol_more:
  1007.       if (symbol->name)
  1008.     fprintf (file, "%s", symbol->name);
  1009.       break;
  1010.     case bfd_print_symbol_all:
  1011.       bfd_print_symbol_vandf ((PTR) file, symbol);
  1012.       fprintf (file, " %-5s", symbol->section->name);
  1013.       if (symbol->name)
  1014.     fprintf (file, " %s", symbol->name);
  1015.       break;
  1016.     }
  1017. }
  1018.  
  1019. /* Slurp in nlm symbol table.
  1020.  
  1021.    In the external (in-file) form, NLM export records are variable length,
  1022.    with the following form:
  1023.  
  1024.     1 byte        length of the symbol name (N)
  1025.     N bytes        the symbol name
  1026.     4 bytes        the symbol offset from start of it's section
  1027.  
  1028.    We also read in the debugging symbols and import records.  Import
  1029.    records are treated as undefined symbols.  As we read the import
  1030.    records we also read in the associated reloc information, which is
  1031.    attached to the symbol.
  1032.  
  1033.    The bfd symbols are copied to SYMPTRS.
  1034.  
  1035.    When we return, the bfd symcount is either zero or contains the correct
  1036.    number of symbols.
  1037. */
  1038.  
  1039. static boolean
  1040. nlm_slurp_symbol_table (abfd)
  1041.      bfd *abfd;
  1042. {
  1043.   Nlm_Internal_Fixed_Header *i_fxdhdrp;    /* Nlm file header, internal form */
  1044.   bfd_size_type totsymcount;    /* Number of NLM symbols */
  1045.   bfd_size_type symcount;    /* Counter of NLM symbols */
  1046.   nlm_symbol_type *sym;        /* Pointer to current bfd symbol */
  1047.   unsigned char symlength;    /* Symbol length read into here */
  1048.   unsigned char symtype;    /* Type of debugging symbol */
  1049.   bfd_byte temp[NLM_TARGET_LONG_SIZE];    /* Symbol offsets read into here */
  1050.   boolean (*read_import_func) PARAMS ((bfd *, nlm_symbol_type *));
  1051.   boolean (*set_public_section_func) PARAMS ((bfd *, nlm_symbol_type *));
  1052.  
  1053.   if (nlm_get_symbols (abfd) != NULL)
  1054.     return (true);
  1055.  
  1056.   /* Read each raw NLM symbol, using the information to create a canonical bfd
  1057.      symbol table entry.
  1058.  
  1059.      Note that we allocate the initial bfd canonical symbol buffer based on a
  1060.      one-to-one mapping of the NLM symbols to canonical symbols.  We actually
  1061.      use all the NLM symbols, so there will be no space left over at the end.
  1062.      When we have all the symbols, we build the caller's pointer vector. */
  1063.  
  1064.   abfd->symcount = 0;
  1065.   i_fxdhdrp = nlm_fixed_header (abfd);
  1066.   totsymcount = (i_fxdhdrp->numberOfPublics
  1067.          + i_fxdhdrp->numberOfDebugRecords
  1068.          + i_fxdhdrp->numberOfExternalReferences);
  1069.   if (totsymcount == 0)
  1070.     {
  1071.       return (true);
  1072.     }
  1073.  
  1074.   if (bfd_seek (abfd, i_fxdhdrp->publicsOffset, SEEK_SET) == -1)
  1075.     return (false);
  1076.  
  1077.   sym = ((nlm_symbol_type *)
  1078.      bfd_zalloc (abfd, totsymcount * sizeof (nlm_symbol_type)));
  1079.   if (!sym)
  1080.     {
  1081.       bfd_set_error (bfd_error_no_memory);
  1082.       return false;
  1083.     }
  1084.   nlm_set_symbols (abfd, sym);
  1085.  
  1086.   /* We use the bfd's symcount directly as the control count, so that early
  1087.      termination of the loop leaves the symcount correct for the symbols that
  1088.      were read. */
  1089.  
  1090.   set_public_section_func = nlm_set_public_section_func (abfd);
  1091.   symcount = i_fxdhdrp->numberOfPublics;
  1092.   while (abfd->symcount < symcount)
  1093.     {
  1094.       if (bfd_read ((PTR) & symlength, sizeof (symlength), 1, abfd)
  1095.       != sizeof (symlength))
  1096.     return (false);
  1097.       sym->symbol.the_bfd = abfd;
  1098.       sym->symbol.name = bfd_alloc (abfd, symlength + 1);
  1099.       if (!sym->symbol.name)
  1100.     {
  1101.       bfd_set_error (bfd_error_no_memory);
  1102.       return false;
  1103.     }
  1104.       if (bfd_read ((PTR) sym->symbol.name, symlength, 1, abfd)
  1105.       != symlength)
  1106.     return (false);
  1107.       /* Cast away const.  */
  1108.       ((char *) (sym->symbol.name))[symlength] = '\0';
  1109.       if (bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp))
  1110.     return (false);
  1111.       sym->symbol.flags = BSF_GLOBAL | BSF_EXPORT;
  1112.       sym->symbol.value = get_word (abfd, temp);
  1113.       if (set_public_section_func)
  1114.     {
  1115.       /* Most backends can use the code below, but unfortunately
  1116.          some use a different scheme.  */
  1117.       if ((*set_public_section_func) (abfd, sym) == false)
  1118.         return false;
  1119.     }
  1120.       else
  1121.     {
  1122.       if (sym->symbol.value & NLM_HIBIT)
  1123.         {
  1124.           sym->symbol.value &= ~NLM_HIBIT;
  1125.           sym->symbol.flags |= BSF_FUNCTION;
  1126.           sym->symbol.section =
  1127.         bfd_get_section_by_name (abfd, NLM_CODE_NAME);
  1128.         }
  1129.       else
  1130.         {
  1131.           sym->symbol.section =
  1132.         bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
  1133.         }
  1134.     }
  1135.       sym->rcnt = 0;
  1136.       abfd->symcount++;
  1137.       sym++;
  1138.     }
  1139.  
  1140.   /* Read the debugging records.  */
  1141.  
  1142.   if (i_fxdhdrp->numberOfDebugRecords > 0)
  1143.     {
  1144.       if (bfd_seek (abfd, i_fxdhdrp->debugInfoOffset, SEEK_SET) == -1)
  1145.     return (false);
  1146.  
  1147.       symcount += i_fxdhdrp->numberOfDebugRecords;
  1148.       while (abfd->symcount < symcount)
  1149.     {
  1150.       if ((bfd_read ((PTR) & symtype, sizeof (symtype), 1, abfd)
  1151.            != sizeof (symtype))
  1152.        || bfd_read ((PTR) temp, sizeof (temp), 1, abfd) != sizeof (temp)
  1153.           || (bfd_read ((PTR) & symlength, sizeof (symlength), 1, abfd)
  1154.           != sizeof (symlength)))
  1155.         return false;
  1156.       sym->symbol.the_bfd = abfd;
  1157.       sym->symbol.name = bfd_alloc (abfd, symlength + 1);
  1158.       if (!sym->symbol.name)
  1159.         {
  1160.           bfd_set_error (bfd_error_no_memory);
  1161.           return false;
  1162.         }
  1163.       if (bfd_read ((PTR) sym->symbol.name, symlength, 1, abfd)
  1164.           != symlength)
  1165.         return (false);
  1166.       /* Cast away const.  */
  1167.       ((char *) (sym->symbol.name))[symlength] = '\0';
  1168.       sym->symbol.flags = BSF_LOCAL;
  1169.       sym->symbol.value = get_word (abfd, temp);
  1170.       if (symtype == 0)
  1171.         {
  1172.           sym->symbol.section =
  1173.         bfd_get_section_by_name (abfd, NLM_INITIALIZED_DATA_NAME);
  1174.         }
  1175.       else if (symtype == 1)
  1176.         {
  1177.           sym->symbol.flags |= BSF_FUNCTION;
  1178.           sym->symbol.section =
  1179.         bfd_get_section_by_name (abfd, NLM_CODE_NAME);
  1180.         }
  1181.       else
  1182.         {
  1183.           sym->symbol.section = bfd_abs_section_ptr;
  1184.         }
  1185.       sym->rcnt = 0;
  1186.       abfd->symcount++;
  1187.       sym++;
  1188.     }
  1189.     }
  1190.  
  1191.   /* Read in the import records.  We can only do this if we know how
  1192.      to read relocs for this target.  */
  1193.  
  1194.   read_import_func = nlm_read_import_func (abfd);
  1195.   if (read_import_func != NULL)
  1196.     {
  1197.       if (bfd_seek (abfd, i_fxdhdrp->externalReferencesOffset, SEEK_SET)
  1198.       == -1)
  1199.     return (false);
  1200.  
  1201.       symcount += i_fxdhdrp->numberOfExternalReferences;
  1202.       while (abfd->symcount < symcount)
  1203.     {
  1204.       if ((*read_import_func) (abfd, sym) == false)
  1205.         return false;
  1206.       sym++;
  1207.       abfd->symcount++;
  1208.     }
  1209.     }
  1210.  
  1211.   return (true);
  1212. }
  1213.  
  1214. /* Get the relocs for an NLM file.  There are two types of relocs.
  1215.    Imports are relocs against symbols defined in other NLM files.  We
  1216.    treat these as relocs against global symbols.  Relocation fixups
  1217.    are internal relocs.
  1218.  
  1219.    The actual format used to store the relocs is machine specific.  */
  1220.  
  1221. /* Read in the relocation fixup information.  This is stored in
  1222.    nlm_relocation_fixups, an array of arelent structures, and
  1223.    nlm_relocation_fixup_secs, an array of section pointers.  The
  1224.    section pointers are needed because the relocs are not sorted by
  1225.    section.  */
  1226.  
  1227. static boolean
  1228. nlm_slurp_reloc_fixups (abfd)
  1229.      bfd *abfd;
  1230. {
  1231.   boolean (*read_func) PARAMS ((bfd *, nlm_symbol_type *, asection **,
  1232.                 arelent *));
  1233.   bfd_size_type count;
  1234.   arelent *rels;
  1235.   asection **secs;
  1236.  
  1237.   if (nlm_relocation_fixups (abfd) != NULL)
  1238.     return true;
  1239.   read_func = nlm_read_reloc_func (abfd);
  1240.   if (read_func == NULL)
  1241.     return true;
  1242.  
  1243.   if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
  1244.         SEEK_SET) != 0)
  1245.     return false;
  1246.  
  1247.   count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
  1248.   rels = (arelent *) bfd_alloc (abfd, count * sizeof (arelent));
  1249.   secs = (asection **) bfd_alloc (abfd, count * sizeof (asection *));
  1250.   if ((rels == NULL || secs == NULL) && count != 0)
  1251.     {
  1252.       bfd_set_error (bfd_error_no_memory);
  1253.       return false;
  1254.     }
  1255.   nlm_relocation_fixups (abfd) = rels;
  1256.   nlm_relocation_fixup_secs (abfd) = secs;
  1257.  
  1258.   /* We have to read piece by piece, because we don't know how large
  1259.      the machine specific reloc information is.  */
  1260.   while (count-- != 0)
  1261.     {
  1262.       if ((*read_func) (abfd, (nlm_symbol_type *) NULL, secs, rels) == false)
  1263.     {
  1264.       nlm_relocation_fixups (abfd) = NULL;
  1265.       nlm_relocation_fixup_secs (abfd) = NULL;
  1266.       return false;
  1267.     }
  1268.       ++secs;
  1269.       ++rels;
  1270.     }
  1271.  
  1272.   return true;
  1273. }
  1274.  
  1275. /* Get the number of relocs.  This really just returns an upper bound,
  1276.    since it does not attempt to distinguish them based on the section.
  1277.    That will be handled when they are actually read.  */
  1278.  
  1279. long
  1280. nlm_get_reloc_upper_bound (abfd, sec)
  1281.      bfd *abfd;
  1282.      asection *sec;
  1283. {
  1284.   nlm_symbol_type *syms;
  1285.   bfd_size_type count;
  1286.   unsigned int ret;
  1287.  
  1288.   /* If we don't know how to read relocs, just return 0.  */
  1289.   if (nlm_read_reloc_func (abfd) == NULL)
  1290.     return -1;
  1291.   /* Make sure we have either the code or the data section.  */
  1292.   if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0)
  1293.     return 0;
  1294.  
  1295.   syms = nlm_get_symbols (abfd);
  1296.   if (syms == NULL)
  1297.     {
  1298.       if (nlm_slurp_symbol_table (abfd) == false)
  1299.     return -1;
  1300.       syms = nlm_get_symbols (abfd);
  1301.     }
  1302.  
  1303.   ret = nlm_fixed_header (abfd)->numberOfRelocationFixups;
  1304.  
  1305.   count = bfd_get_symcount (abfd);
  1306.   while (count-- != 0)
  1307.     {
  1308.       ret += syms->rcnt;
  1309.       ++syms;
  1310.     }
  1311.  
  1312.   return (ret + 1) * sizeof (arelent *);
  1313. }
  1314.  
  1315. /* Get the relocs themselves.  */
  1316.  
  1317. long
  1318. nlm_canonicalize_reloc (abfd, sec, relptr, symbols)
  1319.      bfd *abfd;
  1320.      asection *sec;
  1321.      arelent **relptr;
  1322.      asymbol **symbols;
  1323. {
  1324.   arelent *rels;
  1325.   asection **secs;
  1326.   bfd_size_type count, i;
  1327.   unsigned int ret;
  1328.  
  1329.   /* Get the relocation fixups.  */
  1330.   rels = nlm_relocation_fixups (abfd);
  1331.   if (rels == NULL)
  1332.     {
  1333.       if (nlm_slurp_reloc_fixups (abfd) == false)
  1334.     return -1;
  1335.       rels = nlm_relocation_fixups (abfd);
  1336.     }
  1337.   secs = nlm_relocation_fixup_secs (abfd);
  1338.  
  1339.   ret = 0;
  1340.   count = nlm_fixed_header (abfd)->numberOfRelocationFixups;
  1341.   for (i = 0; i < count; i++, rels++, secs++)
  1342.     {
  1343.       if (*secs == sec)
  1344.     {
  1345.       *relptr++ = rels;
  1346.       ++ret;
  1347.     }
  1348.     }
  1349.  
  1350.   /* Get the import symbols.  */
  1351.   count = bfd_get_symcount (abfd);
  1352.   for (i = 0; i < count; i++, symbols++)
  1353.     {
  1354.       asymbol *sym;
  1355.  
  1356.       sym = *symbols;
  1357.       if (bfd_asymbol_flavour (sym) == bfd_target_nlm_flavour)
  1358.     {
  1359.       nlm_symbol_type *nlm_sym;
  1360.       bfd_size_type j;
  1361.  
  1362.       nlm_sym = (nlm_symbol_type *) sym;
  1363.       for (j = 0; j < nlm_sym->rcnt; j++)
  1364.         {
  1365.           if (nlm_sym->relocs[j].section == sec)
  1366.         {
  1367.           *relptr = &nlm_sym->relocs[j].reloc;
  1368.           (*relptr)->sym_ptr_ptr = symbols;
  1369.           ++relptr;
  1370.           ++ret;
  1371.         }
  1372.         }
  1373.     }
  1374.     }
  1375.  
  1376.   *relptr = NULL;
  1377.  
  1378.   return ret;
  1379. }
  1380.  
  1381. /* Compute the section file positions for an NLM file.  All variable
  1382.    length data in the file headers must be set before this function is
  1383.    called.  If the variable length data is changed later, the
  1384.    resulting object file will be incorrect.  Unfortunately, there is
  1385.    no way to check this.
  1386.  
  1387.    This routine also sets the Size and Offset fields in the fixed
  1388.    header.
  1389.  
  1390.    It also looks over the symbols and moves any common symbols into
  1391.    the .bss section; NLM has no way to represent a common symbol.
  1392.    This approach means that either the symbols must already have been
  1393.    set at this point, or there must be no common symbols.  We need to
  1394.    move the symbols at this point so that mangle_relocs can see the
  1395.    final values.  */
  1396.  
  1397. static boolean
  1398. nlm_compute_section_file_positions (abfd)
  1399.      bfd *abfd;
  1400. {
  1401.   file_ptr sofar;
  1402.   asection *sec;
  1403.   bfd_vma text, data, bss;
  1404.   bfd_vma text_low, data_low;
  1405.   int text_align, data_align, other_align;
  1406.   file_ptr text_ptr, data_ptr, other_ptr;
  1407.   asection *bss_sec;
  1408.   asymbol **sym_ptr_ptr;
  1409.  
  1410.   if (abfd->output_has_begun == true)
  1411.     return true;
  1412.  
  1413.   /* Make sure we have a section to hold uninitialized data.  */
  1414.   bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
  1415.   if (bss_sec == NULL)
  1416.     {
  1417.       if (!add_bfd_section (abfd, NLM_UNINITIALIZED_DATA_NAME,
  1418.                 (file_ptr) 0, (bfd_size_type) 0,
  1419.                 SEC_ALLOC))
  1420.     return false;
  1421.       bss_sec = bfd_get_section_by_name (abfd, NLM_UNINITIALIZED_DATA_NAME);
  1422.     }
  1423.  
  1424.   abfd->output_has_begun = true;
  1425.  
  1426.   /* The fixed header.  */
  1427.   sofar = nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd);
  1428.  
  1429.   /* The variable header.  */
  1430.   sofar += (sizeof (nlm_variable_header (abfd)->descriptionLength)
  1431.         + nlm_variable_header (abfd)->descriptionLength + 1
  1432.         + NLM_TARGET_LONG_SIZE    /* stackSize */
  1433.         + NLM_TARGET_LONG_SIZE    /* reserved */
  1434.         + sizeof (nlm_variable_header (abfd)->oldThreadName)
  1435.         + sizeof (nlm_variable_header (abfd)->screenNameLength)
  1436.         + nlm_variable_header (abfd)->screenNameLength + 1
  1437.         + sizeof (nlm_variable_header (abfd)->threadNameLength)
  1438.         + nlm_variable_header (abfd)->threadNameLength + 1);
  1439.  
  1440.   /* The auxiliary headers.  */
  1441.   if (find_nonzero ((PTR) nlm_version_header (abfd),
  1442.             sizeof (Nlm_Internal_Version_Header)))
  1443.     sofar += sizeof (Nlm_External_Version_Header);
  1444.   if (find_nonzero ((PTR) nlm_extended_header (abfd),
  1445.             sizeof (Nlm_Internal_Extended_Header)))
  1446.     sofar += sizeof (Nlm_External_Extended_Header);
  1447.   if (find_nonzero ((PTR) nlm_copyright_header (abfd),
  1448.             sizeof (Nlm_Internal_Copyright_Header)))
  1449.     sofar += (sizeof (Nlm_External_Copyright_Header)
  1450.           + nlm_copyright_header (abfd)->copyrightMessageLength + 1);
  1451.   if (find_nonzero ((PTR) nlm_custom_header (abfd),
  1452.             sizeof (Nlm_Internal_Custom_Header)))
  1453.     sofar += (sizeof (Nlm_External_Custom_Header)
  1454.           + nlm_custom_header (abfd)->hdrLength);
  1455.   if (find_nonzero ((PTR) nlm_cygnus_ext_header (abfd),
  1456.             sizeof (Nlm_Internal_Cygnus_Ext_Header)))
  1457.     sofar += sizeof (Nlm_External_Custom_Header);
  1458.  
  1459.   /* Compute the section file positions in two passes.  First get the
  1460.      sizes of the text and data sections, and then set the file
  1461.      positions.  This code aligns the sections in the file using the
  1462.      same alignment restrictions that apply to the sections in memory;
  1463.      this may not be necessary.  */
  1464.   text = 0;
  1465.   text_low = (bfd_vma) - 1;
  1466.   text_align = 0;
  1467.   data = 0;
  1468.   data_low = (bfd_vma) - 1;
  1469.   data_align = 0;
  1470.   bss = 0;
  1471.   other_align = 0;
  1472.   for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
  1473.     {
  1474.       flagword f;
  1475.  
  1476.       sec->_raw_size = BFD_ALIGN (sec->_raw_size, 1 << sec->alignment_power);
  1477.  
  1478.       f = bfd_get_section_flags (abfd, sec);
  1479.       if (f & SEC_CODE)
  1480.     {
  1481.       text += sec->_raw_size;
  1482.       if (bfd_get_section_vma (abfd, sec) < text_low)
  1483.         text_low = bfd_get_section_vma (abfd, sec);
  1484.       if (sec->alignment_power > text_align)
  1485.         text_align = sec->alignment_power;
  1486.     }
  1487.       else if (f & SEC_DATA)
  1488.     {
  1489.       data += sec->_raw_size;
  1490.       if (bfd_get_section_vma (abfd, sec) < data_low)
  1491.         data_low = bfd_get_section_vma (abfd, sec);
  1492.       if (sec->alignment_power > data_align)
  1493.         data_align = sec->alignment_power;
  1494.     }
  1495.       else if (f & SEC_HAS_CONTENTS)
  1496.     {
  1497.       if (sec->alignment_power > other_align)
  1498.         other_align = sec->alignment_power;
  1499.     }
  1500.       else if (f & SEC_ALLOC)
  1501.     bss += sec->_raw_size;
  1502.     }
  1503.  
  1504.   nlm_set_text_low (abfd, text_low);
  1505.   nlm_set_data_low (abfd, data_low);
  1506.  
  1507.   if (nlm_no_uninitialized_data (abfd))
  1508.     {
  1509.       /* This NetWare format does not use uninitialized data.  We must
  1510.      increase the size of the data section.  We will never wind up
  1511.      writing those file locations, so they will remain zero.  */
  1512.       data += bss;
  1513.       bss = 0;
  1514.     }
  1515.  
  1516.   text_ptr = BFD_ALIGN (sofar, 1 << text_align);
  1517.   data_ptr = BFD_ALIGN (text_ptr + text, 1 << data_align);
  1518.   other_ptr = BFD_ALIGN (data_ptr + data, 1 << other_align);
  1519.  
  1520.   /* Fill in some fields in the header for which we now have the
  1521.      information.  */
  1522.   nlm_fixed_header (abfd)->codeImageOffset = text_ptr;
  1523.   nlm_fixed_header (abfd)->codeImageSize = text;
  1524.   nlm_fixed_header (abfd)->dataImageOffset = data_ptr;
  1525.   nlm_fixed_header (abfd)->dataImageSize = data;
  1526.   nlm_fixed_header (abfd)->uninitializedDataSize = bss;
  1527.  
  1528.   for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
  1529.     {
  1530.       flagword f;
  1531.  
  1532.       f = bfd_get_section_flags (abfd, sec);
  1533.  
  1534.       if (f & SEC_CODE)
  1535.     {
  1536.       sec->filepos = text_ptr;
  1537.       text_ptr += sec->_raw_size;
  1538.     }
  1539.       else if (f & SEC_DATA)
  1540.     {
  1541.       sec->filepos = data_ptr;
  1542.       data_ptr += sec->_raw_size;
  1543.     }
  1544.       else if (f & SEC_HAS_CONTENTS)
  1545.     {
  1546.       sec->filepos = other_ptr;
  1547.       other_ptr += sec->_raw_size;
  1548.     }
  1549.     }
  1550.  
  1551.   nlm_fixed_header (abfd)->relocationFixupOffset = other_ptr;
  1552.  
  1553.   /* Move all common symbols into the .bss section.  */
  1554.  
  1555.   sym_ptr_ptr = bfd_get_outsymbols (abfd);
  1556.   if (sym_ptr_ptr != NULL)
  1557.     {
  1558.       asymbol **sym_end;
  1559.       bfd_vma add;
  1560.  
  1561.       sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
  1562.       add = 0;
  1563.       for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
  1564.     {
  1565.       asymbol *sym;
  1566.       bfd_vma size;
  1567.  
  1568.       sym = *sym_ptr_ptr;
  1569.  
  1570.       if (!bfd_is_com_section (bfd_get_section (sym)))
  1571.         continue;
  1572.  
  1573.       /* Put the common symbol in the .bss section, and increase
  1574.          the size of the .bss section by the size of the common
  1575.          symbol (which is the old value of the symbol).  */
  1576.       sym->section = bss_sec;
  1577.       size = sym->value;
  1578.       sym->value = bss_sec->_raw_size + add;
  1579.       add += size;
  1580.       add = BFD_ALIGN (add, 1 << bss_sec->alignment_power);
  1581.     }
  1582.       if (add != 0)
  1583.     {
  1584.       if (nlm_no_uninitialized_data (abfd))
  1585.         {
  1586.           /* We could handle this case, but so far it hasn't been
  1587.          necessary.  */
  1588.           abort ();
  1589.         }
  1590.       nlm_fixed_header (abfd)->uninitializedDataSize += add;
  1591.       bss_sec->_raw_size += add;
  1592.     }
  1593.     }
  1594.  
  1595.   return true;
  1596. }
  1597.  
  1598. /* Set the contents of a section.  To do this we need to know where
  1599.    the section is going to be located in the output file.  That means
  1600.    that the sizes of all the sections must be set, and all the
  1601.    variable size header information must be known.  */
  1602.  
  1603. boolean
  1604. nlm_set_section_contents (abfd, section, location, offset, count)
  1605.      bfd *abfd;
  1606.      asection *section;
  1607.      PTR location;
  1608.      file_ptr offset;
  1609.      bfd_size_type count;
  1610. {
  1611.   if (abfd->output_has_begun == false
  1612.       && nlm_compute_section_file_positions (abfd) == false)
  1613.     return false;
  1614.  
  1615.   if (count == 0)
  1616.     return true;
  1617.  
  1618.   /* i386 NetWare has a very restricted set of relocs.  In order for
  1619.      objcopy to work, the NLM i386 backend needs a chance to rework
  1620.      the section contents so that its set of relocs will work.  If all
  1621.      the relocs are already acceptable, this will not do anything.  */
  1622.   if (section->reloc_count != 0)
  1623.     {
  1624.       boolean (*mangle_relocs_func) PARAMS ((bfd *, asection *, PTR,
  1625.                          bfd_vma, bfd_size_type));
  1626.  
  1627.       mangle_relocs_func = nlm_mangle_relocs_func (abfd);
  1628.       if (mangle_relocs_func != NULL)
  1629.     {
  1630.       if (!(*mangle_relocs_func) (abfd, section, location,
  1631.                       (bfd_vma) offset, count))
  1632.         return false;
  1633.     }
  1634.     }
  1635.  
  1636.   if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0
  1637.       || bfd_write (location, 1, count, abfd) != count)
  1638.     return false;
  1639.  
  1640.   return true;
  1641. }
  1642.  
  1643. /* We need to sort a list of relocs associated with sections when we
  1644.    write out the external relocs.  */
  1645.  
  1646. static int
  1647. nlm_external_reloc_compare (p1, p2)
  1648.      const void *p1;
  1649.      const void *p2;
  1650. {
  1651.   const struct reloc_and_sec *r1 = (const struct reloc_and_sec *) p1;
  1652.   const struct reloc_and_sec *r2 = (const struct reloc_and_sec *) p2;
  1653.   int cmp;
  1654.  
  1655.   cmp = strcmp ((*r1->rel->sym_ptr_ptr)->name,
  1656.         (*r2->rel->sym_ptr_ptr)->name);
  1657.   if (cmp != 0)
  1658.     return cmp;
  1659.  
  1660.   /* We sort by address within symbol to make the sort more stable and
  1661.      increase the chances that different hosts will generate bit for
  1662.      bit equivalent results.  */
  1663.   return (int) (r1->rel->address - r2->rel->address);
  1664. }
  1665.  
  1666. /* Write out an NLM file.  We write out the information in this order:
  1667.      fixed header
  1668.      variable header
  1669.      auxiliary headers
  1670.      code sections
  1671.      data sections
  1672.      other sections (custom data, messages, help, shared NLM, RPC,
  1673.                   module dependencies)
  1674.      relocation fixups
  1675.      external references (imports)
  1676.      public symbols (exports)
  1677.      debugging records
  1678.    This is similar to the order used by the NetWare tools; the
  1679.    difference is that NetWare puts the sections other than code, data
  1680.    and custom data at the end of the NLM.  It is convenient for us to
  1681.    know where the sections are going to be before worrying about the
  1682.    size of the other information.
  1683.  
  1684.    By the time this function is called, all the section data should
  1685.    have been output using set_section_contents.  Note that custom
  1686.    data, the message file, the help file, the shared NLM file, the RPC
  1687.    data, and the module dependencies are all considered to be
  1688.    sections; the caller is responsible for filling in the offset and
  1689.    length fields in the NLM headers.  The relocation fixups and
  1690.    imports are both obtained from the list of relocs attached to each
  1691.    section.  The exports and debugging records are obtained from the
  1692.    list of outsymbols.  */
  1693.  
  1694. boolean
  1695. nlm_write_object_contents (abfd)
  1696.      bfd *abfd;
  1697. {
  1698.   asection *sec;
  1699.   boolean (*write_import_func) PARAMS ((bfd *, asection *, arelent *));
  1700.   bfd_size_type external_reloc_count, internal_reloc_count, i, c;
  1701.   struct reloc_and_sec *external_relocs;
  1702.   asymbol **sym_ptr_ptr;
  1703.   file_ptr last;
  1704.   boolean (*write_prefix_func) PARAMS ((bfd *));
  1705.   unsigned char *fixed_header = NULL;
  1706.  
  1707.   fixed_header = (unsigned char *) malloc (nlm_fixed_header_size (abfd));
  1708.   if (fixed_header == NULL)
  1709.     {
  1710.       bfd_set_error (bfd_error_no_memory);
  1711.       goto error_return;
  1712.     }
  1713.  
  1714.   if (abfd->output_has_begun == false
  1715.       && nlm_compute_section_file_positions (abfd) == false)
  1716.     goto error_return;
  1717.  
  1718.   /* Write out the variable length headers.  */
  1719.   if (bfd_seek (abfd,
  1720.          nlm_optional_prefix_size (abfd) + nlm_fixed_header_size (abfd),
  1721.         SEEK_SET) != 0)
  1722.     goto error_return;
  1723.   if (nlm_swap_variable_header_out (abfd) == false
  1724.       || nlm_swap_auxiliary_headers_out (abfd) == false)
  1725.     {
  1726.       bfd_set_error (bfd_error_system_call);
  1727.       goto error_return;
  1728.     }
  1729.  
  1730.   /* A weak check on whether the section file positions were
  1731.      reasonable.  */
  1732.   if (bfd_tell (abfd) > nlm_fixed_header (abfd)->codeImageOffset)
  1733.     {
  1734.       bfd_set_error (bfd_error_invalid_operation);
  1735.       goto error_return;
  1736.     }
  1737.  
  1738.   /* Advance to the relocs.  */
  1739.   if (bfd_seek (abfd, nlm_fixed_header (abfd)->relocationFixupOffset,
  1740.         SEEK_SET) != 0)
  1741.     goto error_return;
  1742.  
  1743.   /* The format of the relocation entries is dependent upon the
  1744.      particular target.  We use an external routine to write the reloc
  1745.      out.  */
  1746.   write_import_func = nlm_write_import_func (abfd);
  1747.  
  1748.   /* Write out the internal relocation fixups.  While we're looping
  1749.      over the relocs, we also count the external relocs, which is
  1750.      needed when they are written out below.  */
  1751.   internal_reloc_count = 0;
  1752.   external_reloc_count = 0;
  1753.   for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
  1754.     {
  1755.       arelent **rel_ptr_ptr, **rel_end;
  1756.  
  1757.       if (sec->reloc_count == 0)
  1758.     continue;
  1759.  
  1760.       /* We can only represent relocs within a code or data
  1761.      section.  We ignore them for a debugging section.  */
  1762.       if ((bfd_get_section_flags (abfd, sec) & (SEC_CODE | SEC_DATA)) == 0)
  1763.     continue;
  1764.  
  1765.       /* We need to know how to write out imports */
  1766.       if (write_import_func == NULL)
  1767.     {
  1768.       bfd_set_error (bfd_error_invalid_operation);
  1769.       goto error_return;
  1770.     }
  1771.  
  1772.       rel_ptr_ptr = sec->orelocation;
  1773.       rel_end = rel_ptr_ptr + sec->reloc_count;
  1774.       for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
  1775.     {
  1776.       arelent *rel;
  1777.       asymbol *sym;
  1778.  
  1779.       rel = *rel_ptr_ptr;
  1780.       sym = *rel->sym_ptr_ptr;
  1781.  
  1782.       if (! bfd_is_und_section (bfd_get_section (sym)))
  1783.         {
  1784.           ++internal_reloc_count;
  1785.           if ((*write_import_func) (abfd, sec, rel) == false)
  1786.         goto error_return;
  1787.         }
  1788.       else
  1789.         ++external_reloc_count;
  1790.     }
  1791.     }
  1792.   nlm_fixed_header (abfd)->numberOfRelocationFixups = internal_reloc_count;
  1793.  
  1794.   /* Write out the imports (relocs against external symbols).  These
  1795.      are output as a symbol name followed by all the relocs for that
  1796.      symbol, so we must first gather together all the relocs against
  1797.      external symbols and sort them.  */
  1798.   external_relocs =
  1799.     (struct reloc_and_sec *) bfd_alloc (abfd,
  1800.                     (external_reloc_count
  1801.                      * sizeof (struct reloc_and_sec)));
  1802.   if (external_relocs == (struct reloc_and_sec *) NULL)
  1803.     {
  1804.       bfd_set_error (bfd_error_no_memory);
  1805.       goto error_return;
  1806.     }
  1807.   i = 0;
  1808.   for (sec = abfd->sections; sec != (asection *) NULL; sec = sec->next)
  1809.     {
  1810.       arelent **rel_ptr_ptr, **rel_end;
  1811.  
  1812.       if (sec->reloc_count == 0)
  1813.     continue;
  1814.  
  1815.       rel_ptr_ptr = sec->orelocation;
  1816.       rel_end = rel_ptr_ptr + sec->reloc_count;
  1817.       for (; rel_ptr_ptr < rel_end; rel_ptr_ptr++)
  1818.     {
  1819.       arelent *rel;
  1820.       asymbol *sym;
  1821.  
  1822.       rel = *rel_ptr_ptr;
  1823.       sym = *rel->sym_ptr_ptr;
  1824.  
  1825.       if (! bfd_is_und_section (bfd_get_section (sym)))
  1826.         continue;
  1827.  
  1828.       external_relocs[i].rel = rel;
  1829.       external_relocs[i].sec = sec;
  1830.       ++i;
  1831.     }
  1832.     }
  1833.  
  1834.   BFD_ASSERT (i == external_reloc_count);
  1835.  
  1836.   /* Sort the external relocs by name.  */
  1837.   qsort ((PTR) external_relocs, (size_t) external_reloc_count,
  1838.      sizeof (struct reloc_and_sec), nlm_external_reloc_compare);
  1839.  
  1840.   /* Write out the external relocs.  */
  1841.   nlm_fixed_header (abfd)->externalReferencesOffset = bfd_tell (abfd);
  1842.   c = 0;
  1843.   i = 0;
  1844.   while (i < external_reloc_count)
  1845.     {
  1846.       arelent *rel;
  1847.       asymbol *sym;
  1848.       bfd_size_type j, cnt;
  1849.  
  1850.       ++c;
  1851.  
  1852.       rel = external_relocs[i].rel;
  1853.       sym = *rel->sym_ptr_ptr;
  1854.  
  1855.       cnt = 0;
  1856.       for (j = i;
  1857.        (j < external_reloc_count
  1858.         && *external_relocs[j].rel->sym_ptr_ptr == sym);
  1859.        j++)
  1860.     ++cnt;
  1861.  
  1862.       if ((*nlm_write_external_func (abfd)) (abfd, cnt, sym,
  1863.                          &external_relocs[i])
  1864.       == false)
  1865.     goto error_return;
  1866.  
  1867.       i += cnt;
  1868.     }
  1869.  
  1870.   nlm_fixed_header (abfd)->numberOfExternalReferences = c;
  1871.  
  1872.   /* Write out the public symbols (exports).  */
  1873.   sym_ptr_ptr = bfd_get_outsymbols (abfd);
  1874.   if (sym_ptr_ptr != (asymbol **) NULL)
  1875.     {
  1876.       bfd_vma (*get_public_offset_func) PARAMS ((bfd *, asymbol *));
  1877.       boolean (*write_export_func) PARAMS ((bfd *, asymbol *, bfd_vma));
  1878.  
  1879.       asymbol **sym_end;
  1880.  
  1881.       nlm_fixed_header (abfd)->publicsOffset = bfd_tell (abfd);
  1882.       get_public_offset_func = nlm_get_public_offset_func (abfd);
  1883.       write_export_func = nlm_write_export_func (abfd);
  1884.       c = 0;
  1885.       sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
  1886.       for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
  1887.     {
  1888.       asymbol *sym;
  1889.       bfd_byte len;
  1890.       bfd_vma offset;
  1891.       bfd_byte temp[NLM_TARGET_LONG_SIZE];
  1892.  
  1893.       sym = *sym_ptr_ptr;
  1894.  
  1895.       if ((sym->flags & (BSF_EXPORT | BSF_GLOBAL)) == 0
  1896.           || bfd_is_und_section (bfd_get_section (sym)))
  1897.         continue;
  1898.  
  1899.       ++c;
  1900.  
  1901.       if (get_public_offset_func)
  1902.         {
  1903.           /* Most backends can use the code below, but
  1904.          unfortunately some use a different scheme.  */
  1905.           offset = (*get_public_offset_func) (abfd, sym);
  1906.         }
  1907.       else
  1908.         {
  1909.           offset = bfd_asymbol_value (sym);
  1910.           sec = sym->section;
  1911.           if (sec->flags & SEC_CODE)
  1912.         {
  1913.           offset -= nlm_get_text_low (abfd);
  1914.           offset |= NLM_HIBIT;
  1915.         }
  1916.           else if (sec->flags & (SEC_DATA | SEC_ALLOC))
  1917.         {
  1918.           /* SEC_ALLOC is for the .bss section.  */
  1919.           offset -= nlm_get_data_low (abfd);
  1920.         }
  1921.           else
  1922.         {
  1923.           /* We can't handle an exported symbol that is not in
  1924.              the code or data segment.  */
  1925.           bfd_set_error (bfd_error_invalid_operation);
  1926.           goto error_return;
  1927.         }
  1928.         }
  1929.  
  1930.       if (write_export_func)
  1931.         {
  1932.           if ((*write_export_func) (abfd, sym, offset) == false)
  1933.         goto error_return;
  1934.         }
  1935.       else
  1936.         {
  1937.           len = strlen (sym->name);
  1938.           if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
  1939.            != sizeof (bfd_byte))
  1940.           || bfd_write (sym->name, len, 1, abfd) != len)
  1941.         goto error_return;
  1942.  
  1943.           put_word (abfd, offset, temp);
  1944.           if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
  1945.         goto error_return;
  1946.         }
  1947.     }
  1948.       nlm_fixed_header (abfd)->numberOfPublics = c;
  1949.  
  1950.       /* Write out the debugging records.  The NLM conversion program
  1951.      wants to be able to inhibit this, so as a special hack if
  1952.      debugInfoOffset is set to -1 we don't write any debugging
  1953.      information.  This can not be handled by fiddling with the
  1954.      symbol table, because exported symbols appear in both the
  1955.      exported symbol list and the debugging information.  */
  1956.       if (nlm_fixed_header (abfd)->debugInfoOffset == (file_ptr) - 1)
  1957.     {
  1958.       nlm_fixed_header (abfd)->debugInfoOffset = 0;
  1959.       nlm_fixed_header (abfd)->numberOfDebugRecords = 0;
  1960.     }
  1961.       else
  1962.     {
  1963.       nlm_fixed_header (abfd)->debugInfoOffset = bfd_tell (abfd);
  1964.       c = 0;
  1965.       sym_ptr_ptr = bfd_get_outsymbols (abfd);
  1966.       sym_end = sym_ptr_ptr + bfd_get_symcount (abfd);
  1967.       for (; sym_ptr_ptr < sym_end; sym_ptr_ptr++)
  1968.         {
  1969.           asymbol *sym;
  1970.           bfd_byte type, len;
  1971.           bfd_vma offset;
  1972.           bfd_byte temp[NLM_TARGET_LONG_SIZE];
  1973.  
  1974.           sym = *sym_ptr_ptr;
  1975.  
  1976.           /* The NLM notion of a debugging symbol is actually what
  1977.          BFD calls a local or global symbol.  What BFD calls a
  1978.          debugging symbol NLM does not understand at all.  */
  1979.           if ((sym->flags & (BSF_LOCAL | BSF_GLOBAL | BSF_EXPORT)) == 0
  1980.           || (sym->flags & BSF_DEBUGGING) != 0
  1981.           || bfd_is_und_section (bfd_get_section (sym)))
  1982.         continue;
  1983.  
  1984.           ++c;
  1985.  
  1986.           offset = bfd_asymbol_value (sym);
  1987.           sec = sym->section;
  1988.           if (sec->flags & SEC_CODE)
  1989.         {
  1990.           offset -= nlm_get_text_low (abfd);
  1991.           type = 1;
  1992.         }
  1993.           else if (sec->flags & (SEC_DATA | SEC_ALLOC))
  1994.         {
  1995.           /* SEC_ALLOC is for the .bss section.  */
  1996.           offset -= nlm_get_data_low (abfd);
  1997.           type = 0;
  1998.         }
  1999.           else
  2000.         type = 2;
  2001.  
  2002.           /* The type is 0 for data, 1 for code, 2 for absolute.  */
  2003.           if (bfd_write (&type, sizeof (bfd_byte), 1, abfd)
  2004.           != sizeof (bfd_byte))
  2005.         goto error_return;
  2006.  
  2007.           put_word (abfd, offset, temp);
  2008.           if (bfd_write (temp, sizeof (temp), 1, abfd) != sizeof (temp))
  2009.         goto error_return;
  2010.  
  2011.           len = strlen (sym->name);
  2012.           if ((bfd_write (&len, sizeof (bfd_byte), 1, abfd)
  2013.            != sizeof (bfd_byte))
  2014.           || bfd_write (sym->name, len, 1, abfd) != len)
  2015.         goto error_return;
  2016.         }
  2017.       nlm_fixed_header (abfd)->numberOfDebugRecords = c;
  2018.     }
  2019.     }
  2020.  
  2021.   /* NLMLINK fills in offset values even if there is no data, so we do
  2022.      the same.  */
  2023.   last = bfd_tell (abfd);
  2024.   if (nlm_fixed_header (abfd)->codeImageOffset == 0)
  2025.     nlm_fixed_header (abfd)->codeImageOffset = last;
  2026.   if (nlm_fixed_header (abfd)->dataImageOffset == 0)
  2027.     nlm_fixed_header (abfd)->dataImageOffset = last;
  2028.   if (nlm_fixed_header (abfd)->customDataOffset == 0)
  2029.     nlm_fixed_header (abfd)->customDataOffset = last;
  2030.   if (nlm_fixed_header (abfd)->moduleDependencyOffset == 0)
  2031.     nlm_fixed_header (abfd)->moduleDependencyOffset = last;
  2032.   if (nlm_fixed_header (abfd)->relocationFixupOffset == 0)
  2033.     nlm_fixed_header (abfd)->relocationFixupOffset = last;
  2034.   if (nlm_fixed_header (abfd)->externalReferencesOffset == 0)
  2035.     nlm_fixed_header (abfd)->externalReferencesOffset = last;
  2036.   if (nlm_fixed_header (abfd)->publicsOffset == 0)
  2037.     nlm_fixed_header (abfd)->publicsOffset = last;
  2038.   if (nlm_fixed_header (abfd)->debugInfoOffset == 0)
  2039.     nlm_fixed_header (abfd)->debugInfoOffset = last;
  2040.  
  2041.   /* At this point everything has been written out except the fixed
  2042.      header.  */
  2043.   memcpy (nlm_fixed_header (abfd)->signature, nlm_signature (abfd),
  2044.       NLM_SIGNATURE_SIZE);
  2045.   nlm_fixed_header (abfd)->version = NLM_HEADER_VERSION;
  2046.   nlm_fixed_header (abfd)->codeStartOffset =
  2047.     (bfd_get_start_address (abfd)
  2048.      - nlm_get_text_low (abfd));
  2049.  
  2050.   /* We have no convenient way for the caller to pass in the exit
  2051.      procedure or the check unload procedure, so the caller must set
  2052.      the values in the header to the values of the symbols.  */
  2053.   nlm_fixed_header (abfd)->exitProcedureOffset -= nlm_get_text_low (abfd);
  2054.   if (nlm_fixed_header (abfd)->checkUnloadProcedureOffset != 0)
  2055.     nlm_fixed_header (abfd)->checkUnloadProcedureOffset -=
  2056.       nlm_get_text_low (abfd);
  2057.  
  2058.   if (bfd_seek (abfd, 0, SEEK_SET) != 0)
  2059.     goto error_return;
  2060.  
  2061.   write_prefix_func = nlm_write_prefix_func (abfd);
  2062.   if (write_prefix_func)
  2063.     {
  2064.       if ((*write_prefix_func) (abfd) == false)
  2065.     goto error_return;
  2066.     }
  2067.  
  2068.   BFD_ASSERT (bfd_tell (abfd) == nlm_optional_prefix_size (abfd));
  2069.  
  2070.   nlm_swap_fixed_header_out (abfd, nlm_fixed_header (abfd), fixed_header);
  2071.   if (bfd_write (fixed_header, nlm_fixed_header_size (abfd), 1, abfd)
  2072.       != nlm_fixed_header_size (abfd))
  2073.     goto error_return;
  2074.  
  2075.   if (fixed_header != NULL)
  2076.     free (fixed_header);
  2077.   return true;
  2078.  
  2079. error_return:
  2080.   if (fixed_header != NULL)
  2081.     free (fixed_header);
  2082.   return false;
  2083. }
  2084.